package com.example.question.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.example.question.entity.Question;
import com.example.question.mapper.QuestionMapper;
import com.example.question.service.QuestionService;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.StringUtils;

import java.util.List;

/**
 * 题目服务实现类
 * 实现QuestionService接口定义的所有业务方法
 * 继承ServiceImpl获取MyBatis-Plus提供的基础CRUD功能
 * @author 颜殿
 */
@Service
public class QuestionServiceImpl extends ServiceImpl<QuestionMapper, Question> implements QuestionService {

    /**
     * 添加题目
     * 调用MyBatis-Plus的save方法保存实体
     * @param question 题目实体
     * @return 添加是否成功
     */
    @Override
    public boolean addQuestion(Question question) {
        return save(question);
    }

    /**
     * 删除题目
     * 调用MyBatis-Plus的removeById方法删除记录
     * @param id 要删除的题目ID
     * @return 删除是否成功
     */
    @Override
    public boolean deleteQuestion(Integer id) {
        return removeById(id);
    }

    /**
     * 批量删除题目
     * 调用MyBatis-Plus的removeByIds方法批量删除记录
     * @param ids 要删除的题目ID列表
     * @return 删除是否成功
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public boolean batchDeleteQuestions(List<Integer> ids) {
        return removeByIds(ids);
    }

    /**
     * 修改题目
     * 调用MyBatis-Plus的updateById方法更新记录
     * @param question 包含更新信息的题目实体
     * @return 更新是否成功
     */
    @Override
    public boolean updateQuestion(Question question) {
        return updateById(question);
    }

    /**
     * 创建分页对象
     * @param pageNum 页码
     * @param pageSize 条数
     * @return 分页对象
     */
    private Page<Question> createPage(Integer pageNum, Integer pageSize) {
        return new Page<>(pageNum, pageSize);
    }

    /**
     * 根据分类分页查询题目
     * 使用自定义Mapper方法进行查询
     * 根据分类名称与题目标题进行比对查询
     * @param pageNum 页码，从1开始
     * @param pageSize 每页记录数
     * @param name 分类ID或JSON参数
     * @return 分页结果，包含题目列表和分页信息
     */
    @Override
    public Page<Question> pageByCategory(Integer pageNum, Integer pageSize, String name) {
        Page<Question> page = new Page<>(pageNum, pageSize);
    
        if (name != null && !name.isEmpty()) {
            try {
                String categoryName = name;
                // 如果是JSON格式，尝试解析
                if (name.startsWith("{")) {
                    ObjectMapper mapper = new ObjectMapper();
                    JsonNode node = mapper.readTree(name);
                    if (node.has("name")) {
                        categoryName = node.get("name").asText();
                    }
                }
    
                if (categoryName != null && !categoryName.isEmpty()) {
                    return (Page<Question>) baseMapper.selectPageByCategory(page, categoryName);
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    
        // 如果没有有效的分类名称，返回空的分页结果
        page.setRecords(java.util.Collections.emptyList());
        return page;
    }

    /**
     * 根据难度分页查询题目
     * 使用自定义Mapper方法进行查询
     * 如果difficulty不为空，则添加难度条件
     * @param pageNum 页码，从1开始
     * @param pageSize 每页记录数
     * @param difficulty 难度级别，可为null表示查询所有难度
     * @return 分页结果，包含题目列表和分页信息
     */
    @Override
    public Page<Question> pageByDifficulty(Integer pageNum, Integer pageSize, String difficulty) {
        Page<Question> page = new Page<>(pageNum, pageSize);
        
        if (difficulty != null) {
            // 处理JSON格式的difficulty参数
            String process = difficulty;
            if (difficulty.startsWith("{")) {
                try {
                    ObjectMapper mapper = new ObjectMapper();
                    JsonNode node = mapper.readTree(difficulty);
                    if (node.has("difficulty")) {
                        process = node.get("difficulty").asText();
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }

            // 将字符串转换为Difficulty枚举
            try {
                Question.Difficulty difficultyEnum = Question.Difficulty.valueOf(process);
                // 使用自定义Mapper方法查询
                return baseMapper.selectPageByDifficulty(page, difficultyEnum);
            } catch (IllegalArgumentException e) {
                // 如果转换失败，可以记录日志或抛出异常
                e.printStackTrace();
            }
        }
        
        // 如果difficulty为空或转换失败，返回所有记录
        LambdaQueryWrapper<Question> wrapper = new LambdaQueryWrapper<>();
        wrapper.select(Question::getId, Question::getTitle, Question::getDescription, 
                Question::getDifficulty, Question::getStatus, Question::getTags, 
                Question::getExpectedTime, Question::getMaxScore, Question::getAnswer, 
                Question::getCreatedAt, Question::getUpdatedAt, Question::getProblemsetId);
        return page(page, wrapper);
    }

    /**
     * 根据状态分页查询题目
     * 使用自定义Mapper方法进行查询
     * 处理前端传入的JSON参数
     * @param pageNum 页码，从1开始
     * @param pageSize 每页记录数
     * @param status 状态值JSON参数，可为null表示查询所有状态
     * @return 分页结果，包含题目列表和分页信息
     */
    @Override
    public Page<Question> pageByStatus(Integer pageNum, Integer pageSize, Integer status) {
        Page<Question> page = new Page<>(pageNum, pageSize);
        LambdaQueryWrapper<Question> wrapper = new LambdaQueryWrapper<>();
        
        // 添加状态条件
        if (status != null) {
            wrapper.eq(Question::getStatus, status);
        }
        
        wrapper.select(Question::getId, Question::getTitle, Question::getDescription, 
                Question::getDifficulty, Question::getStatus, Question::getTags, 
                Question::getExpectedTime, Question::getMaxScore, Question::getAnswer, 
                Question::getCreatedAt, Question::getUpdatedAt, Question::getProblemsetId);
        return page(page, wrapper);
    }

    /**
     * 根据描述分页查询题目
     * 使用自定义Mapper方法进行查询
     * 处理前端传入的JSON参数
     * @param pageNum 页码，从1开始
     * @param pageSize 每页记录数
     * @param description 描述关键词，可为null表示查询所有题目
     * @return 分页结果，包含题目列表和分页信息
     */
    @Override
    public Page<Question> pageByDescription(Integer pageNum, Integer pageSize, String description) {
        Page<Question> page = new Page<>(pageNum, pageSize);
        
        if (description != null && !description.isEmpty()) {
            // 处理JSON格式的description参数
            String keyword = description;
            
            try {
                // 如果是JSON字符串，解析它
                if (description.startsWith("{")) {
                    ObjectMapper mapper = new ObjectMapper();
                    JsonNode node = mapper.readTree(description);
                    if (node.has("description")) {
                        keyword = node.get("description").asText();
                    } else if (node.has("keyword")) {
                        keyword = node.get("keyword").asText();
                    }
                }
                
                // 使用自定义Mapper方法查询
                if (keyword != null && !keyword.isEmpty()) {
                    return baseMapper.selectPageByDescription(page, keyword);
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        
        // 如果没有有效的关键词或解析失败，返回所有记录
        LambdaQueryWrapper<Question> wrapper = new LambdaQueryWrapper<>();
        wrapper.select(Question::getId, Question::getTitle, Question::getDescription, 
                Question::getDifficulty, Question::getStatus, Question::getTags, 
                Question::getExpectedTime, Question::getMaxScore, Question::getAnswer, 
                Question::getCreatedAt, Question::getUpdatedAt, Question::getProblemsetId);
        return page(page, wrapper);
    }

    /**
     * 根据题目集ID查询题目
     * 使用LambdaQueryWrapper构建查询条件
     * 根据题目集ID精确匹配
     * @param setId 题目集ID
     * @return 题目列表
     */
    @Override
    public List<Question> getQuestionsBySetId(Integer setId) {
        LambdaQueryWrapper<Question> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(Question::getProblemsetId, setId);
        return list(wrapper);
    }

    /**
     * 根据题目集ID查询题目数量
     * @param problemsetId 题目集ID
     * @return 题目数量
     */
    @Override
    public Long countByProblemsetId(Integer problemsetId) {
        LambdaQueryWrapper<Question> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(Question::getProblemsetId, problemsetId);
        return count(wrapper);
    }

    /**
     * 基础分页查询
     * @param page 分页参数
     * @return 分页结果
     */
    @Override
    public Page<Question> page(Page<Question> page) {
        LambdaQueryWrapper<Question> wrapper = new LambdaQueryWrapper<>();
        wrapper.select(Question::getId, Question::getTitle, Question::getDescription, 
                Question::getDifficulty, Question::getStatus, Question::getTags, 
                Question::getExpectedTime, Question::getMaxScore, Question::getAnswer, 
                Question::getCreatedAt, Question::getUpdatedAt, Question::getProblemsetId);
        return page(page, wrapper);
    }
}